Pandas实战 |
您所在的位置:网站首页 › date of birth和birthday › Pandas实战 |
本文将主要介绍以下内容: 1. DataFrame概述 2. Series和DataFrame的相似点 3. DataFrame排序 4. 按DataFrame索引排序 5. 设置新索引 6. 从DataFrame读取列 7. 从DataFrame读取行 8. 重命名列或行 9. 重置索引
DataFrame是Pandas的另外一个主要的数据结构,它是由行和列组成的二维数据结构,因此需要两个参考点来从数据集中提取给定值。 1. DataFrame概述 DataFrame可以描述为网格或数据表,类似于Excel之类的电子表格中的网格或数据表。 1.1 从字典创建DataFrame 和往常一样,让我们从导入pandas开始,还将使用NumPy库生成一些随机数据: In [1]: import pandas as pd import numpy as np在导入第一个数据集之前,让我们练习从一些Python内置对象实例化一个DataFrame。例如字典,其键将用作列名,而相应的值将用作该列的值。 下例使用三个长度相等的列表来存储城市,国家和人口。也可以使用其它可迭代对象(如元组或Series)代替列表。DataFrame类的第一个参数data代表数据源。 In [2]: city_data = { "City": ["New York City", "Paris", "Barcelona", "Rome"], "Country": ["United States", "France", "Spain", "Italy"], "Population": [8600000, 2141000, 5515000, 2873000] } cities = pd.DataFrame(city_data) cities Out [2]: City Country Population 0 New York City United States 8600000 1 Paris France 2141000 2 Barcelona Spain 5515000 3 Rome Italy 2873000我们创建了第一个DataFrame,它与Series非常相似。再次提醒,当我们没有为构造函数提供一个明确的索引时,pandas会默认生成一个从0开始的顺序索引。 如果我们想翻转数据,以列标头作为索引标签,我们可以调用transpose方法或其T属性: In [3]: cities.transpose() # 此行代码和下面代码是一样的 cities.T Out [3]: 0 1 2 3 City New York City Paris Barcelona Rome Country United States France Spain Italy Population 8600000 2141000 5515000 2873000另外还可以使用一个更方便的from_dict方法,此方法用于把字典转换为DataFrame。其参数orient用于控制索引标签的创建,如果想把字典的键保存为DataFrame的列,可以使用默认值columns;如果想把字典的键保存为行,则使用值index: In [4]: pd.DataFrame.from_dict(data = city_data, orient = "index") Out [4]: 0 1 2 3 City New York City Paris Barcelona Rome Country United States France Spain Italy Population 8600000 2141000 5515000 28730001.2 从NumPy 数组创建DataFrame DataFrame构造函数还接受NumPy ndarray对象。假设我们要创建一个3x5的DataFrame,其整数在1到100(含)之间,我们可以使用random模块的randint方法: In [5]: data = np.random.randint(1, 101, [3, 5]) data Out [5]: array([[25, 22, 80, 43, 42], [40, 89, 7, 21, 25], [89, 71, 32, 28, 39]])接下来,我们将ndarray传到DataFrame构造函数中。与行一样,如果未提供自定义的列标头,Pandas将为每列分配一个数字索引: In [6]: pd.DataFrame(data = data) Out [6]: 0 1 2 3 4 0 25 22 80 43 42 1 40 89 7 21 25 2 89 71 32 28 39我们可以使用可迭代序列,例如列表,元组或ndarray,以用作行标签。请注意,可迭代项的长度必须等于数据集中的行数。这是一个3x5的表格,因此我们必须为索引提供3个标签。 In [7]: index = ["Morning", "Afternoon", "Evening"] temperatures = pd.DataFrame(data = data, index = index) temperatures Out [7]: 0 1 2 3 4 Morning 25 22 80 43 42 Afternoon 40 89 7 21 25 Evening 89 71 32 28 39columns参数允许我们设置DataFrame的列名(也称为垂直标签)。因为我们总共有5列,所以我们的可迭代项的长度必须为5。下例通过将标头存储在元组中来设置列名: In [8]: index = ["Morning", "Afternoon", "Evening"] columns = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday") temperatures = pd.DataFrame(data = data, index = index, columns = columns) temperatures Out [8]: Monday Tuesday Wednesday Thursday Friday Morning 25 22 80 43 42 Afternoon 40 89 7 21 25 Evening 89 71 32 28 39行索引和列索引都允许包含重复值: In [9]: index = ["Morning", "Afternoon", " Morning"] columns = ("Monday", "Tuesday", "Wednesday", "Tuesday", "Friday") temperatures = pd.DataFrame(data = data, index = index, columns = columns) temperatures Out [9]: Monday Tuesday Wednesday Tuesday Friday Morning 25 22 80 43 42 Afternoon 40 89 7 21 25 Morning 89 71 32 28 392. Series和DataFrame的相似点 在之前介绍的许多Series属性和方法在DataFrame上也适用。 2.1 导入CSV数据集 nba.csv文件是2019-2020 NBA运动员的数据集,包括每个球员的姓名,球队,位置,生日和工资: In [10]: pd.read_csv("nba.csv") Out [10]: Name Team Position Birthday Salary 0 Shake Milton Philadelphia 76ers SG 9/26/96 1445697 1 Christian Wood Detroit Pistons PF 9/27/95 1645357 2 PJ Washington Charlotte Hornets PF 8/23/98 3831840 3 Derrick Rose Detroit Pistons PG 10/4/88 7317074 4 Marial Shayok Philadelphia 76ers G 7/26/95 79568 … … … … … … 445 Austin Rivers Houston Rockets PG 8/1/92 2174310 446 Harry Giles Sacramento Kings PF 4/22/98 2578800 447 Robin Lopez Milwaukee Bucks C 4/1/88 4767000 448 Collin Sexton Cleveland Cavaliers PG 1/4/99 4764960 449 Ricky Rubio Phoenix Suns PG 10/21/90 16200000 450 rows x 5 columns注意,Birthday列中的值默认是作为字符串而不是datetime对象导入,之前介绍过可以使用parse_dates参数将值强制转换为datetime,一致以YYYY-MM-DD格式显示: In [11]: pd.read_csv("nba.csv", parse_dates = ["Birthday"]) Out [11]: Name Team Position Birthday Salary 0 Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 1 Christian Wood Detroit Pistons PF 1995-09-27 1645357 2 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 3 Derrick Rose Detroit Pistons PG 1988-10-04 7317074 4 Marial Shayok Philadelphia 76ers G 1995-07-26 79568 … … … … … … 445 Austin Rivers Houston Rockets PG 1992-08-01 2174310 446 Harry Giles Sacramento Kings PF 1998-04-22 2578800 447 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000 448 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960 449 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000 450 rows x 5 columns现在我们可以把DataFrame分配给一个变量nba: In [12]: nba = pd.read_csv("nba.csv", parse_dates = ["Birthday"])2.2 共享和专用属性 Series的值必须是单一同质的数据类型,而DataFrame的列可以保存异构的数据。让我们使用dtypes属性查看各自的数据类型,它返回的是一个Series对象: In [13]: nba.dtypes Out [13]: Name object Team object Position object Birthday datetime64[ns] Salary int64 dtype: object然后调用value_counts方法可以计算每种数据类型的列数: In [14]: nba.dtypes.value_counts() Out [14]: object 3 datetime64[ns] 1 int64 1 dtype: int64DataFrame基本上由两个对象组成:一个由行标签组成的索引和一个保存每一行值的数据容器。Pandas自带了几个索引对象,每个索引对象都经过优化以存储特定类型的值(numeric、string、datetime等)。index属性返回DataFrame的Index对象。下面让我们看一下nba数据集使用的索引类型: In [15]: nba.index Out [15]: RangeIndex(start=0, stop=450, step=1)RangeIndex是一个优化的索引,用于存储顺序的整数值。与Python的range函数非常相似,RangeIndex包含三个参数:start,stop和step(每两个值之间的间隔)。上例的输出告诉我们索引从0开始,以1为增量(即0、1、2…449)直到450。 DataFrame还具有专用的columns属性,该属性返回包含标头的Index对象: In [16]: nba.columns Out [16]: Index(['Name', 'Team', 'Position', 'Birthday', 'Salary'], dtype='object')axes属性同时返回行和列索引: In [17]: nba.axes Out [17]: [RangeIndex(start=0, stop=450, step=1), Index(['Name', 'Team', 'Position', 'Birthday', 'Salary'], dtype='object')]shape属性返回DataFrame维度的元组,450行x 5列: In [18]: nba.shape Out [18]: (450, 5)ndim属性返回维数: In [19]: nba.ndim Out [19]: 2size属性返回数据集中值的总数,包括缺失值,它等于行数和列数的乘积: In [20]: nba.size Out [20]: 2250 In [21]: len(nba.index) * len(nba.columns) Out [21]: 2250如果要排除缺失值可以使用count方法,它将返回一个包含每个DataFrame列的非空值数量的Series。然后使用sum方法得出DataFrame中非空值的总数。因为此数据集不包含任何缺失值,所以size属性和count方法的结果将相同。 In [22]: nba.count() Out [22]: Name 450 Team 450 Position 450 Birthday 450 Salary 450 dtype: int64 In [23]: nba.count().sum() Out [23]: 22502.3 共享方法 head和tail方法返回数据集的最前或最后的行: In [24]: nba.head(2) Out [24]: Name Team Position Birthday Salary 0 Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 1 Christian Wood Detroit Pistons PF 1995-09-27 1645357 In [25]: nba.tail(n = 3) Out [25]: Name Team Position Birthday Salary 447 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000 448 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960 449 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000sample方法返回DataFrame的随机行: In [26]: nba.sample(3) Out [26]: Name Team Position Birthday Salary 348 Patrick Patterson Los Angeles Clippers PF 1989-03-14 3068660 14 Alec Burks Golden State Warriors SG 1991-07-20 2320044 228 Ignas Brazdeikis New York Knicks SF 1999-01-08 898310nunique方法返回一个包含每一列唯一值的数量的Series: In [27]: nba.nunique() Out [27]: Name 450 Team 30 Position 9 Birthday 430 Salary 269 dtype: int64之前介绍过的max和min方法在DataFrame上也适用,它们返回包含每一列的最大值和最小值的Series。datetime列的最大值是按时间顺序排列的最新日期。 In [28]: nba.max() Out [28]: Team Washington Wizards Position SG Birthday 2000-12-23 00:00:00 Salary 40231758 dtype: object In [29]: nba.min() Out [29]: Team Atlanta Hawks Position C Birthday 1977-01-26 00:00:00 Salary 79568 dtype: objectnlargest方法返回按照指定列最大值排序的前n行。因为一个DataFrame可以包含多个可排序的列,所以我们必须使用columns参数指定要用作排序的列。参数值可以是单个列名,也可以是多个列名的列表。下例是返回NBA中收入最高的前4名球员: In [30]: nba.nlargest(n = 4, columns = "Salary") Out [30]: Name Team Position Birthday Salary 205 Stephen Curry Golden State Warriors PG 1988-03-14 40231758 38 Chris Paul Oklahoma City Thunder PG 1985-05-06 38506482 219 Russell Westbrook Houston Rockets PG 1988-11-12 38506482 251 John Wall Washington Wizards PG 1990-09-06 38199000nsmallest方法返回按照指定列最小值排序的前n行。下例是返回NBA中最老的前3名球员: In [31]: nba.nsmallest(3, columns = ["Birthday"]) Out [31]: is Name Team Position Birthday Salary 98 Vince Carter Atlanta Hawks PF 1977-01-26 2564753 196 Udonis Haslem Miami Heat C 1980-06-09 2564753 262 Kyle Korver Milwaukee Bucks PF 1981-03-17 6004753如果要计算所有NBA工资的总和,可以直接使用sum方法,但必须把numeric_only参数设为True,用于只计算数值类型的列。 In [32]: nba.sum(numeric_only = True) Out [32]: Salary 3444112694 dtype: int64mean方法可以计算平均工资: In [33]: nba.mean() Out [33]: Salary 7.653584e+06 dtype: float64median方法可以计算工资的中位数,std方法统计偏差: In [34]: nba.median() Out [34]: Salary 3303074.5 dtype: float64 In [35]: nba.std() Out [35]: Salary 9.288810e+06 dtype: float643. 按DataFrame值排序 我们可以使用sort_values方法按一列或多列对DataFrame进行排序。默认情况下,该方法返回一个新的DataFrame。 3.1 按单列排序 首先让我们按名字对球员进行排序,by参数用于指定排序的列: In [36]: nba.sort_values("Name") # 和下面代码是一样的 nba.sort_values(by = "Name") Out [36]: Name Team Position Birthday Salary 52 Aaron Gordon Orlando Magic PF 1995-09-16 19863636 101 Aaron Holiday Indiana Pacers PG 1996-09-30 2239200 437 Abdel Nader Oklahoma City Thunder SF 1993-09-25 1618520 81 Adam Mokoka Chicago Bulls G 1998-07-18 79568 399 Admiral Schofield Washington Wizards SF 1997-03-30 1000000 … … … … … … 159 Zach LaVine Chicago Bulls PG 1995-03-10 19500000 302 Zach Norvell Los Angeles Lakers SG 1997-12-09 79568 312 Zhaire Smith Philadelphia 76ers SG 1999-06-04 3058800 137 Zion Williamson New Orleans Pelicans F 2000-07-06 9757440 248 Zylan Cheatham New Orleans Pelicans SF 1995-11-17 79568 450 rows × 5 columnsascending参数可以指定升序或降序排序,我们可以使用它来找出NBA中最年轻的五个球员,只需对Birthday列进行降序排序,head方法默认返回前5行: In [37]: nba.sort_values("Birthday", ascending = False).head() Out [37]: Name Team Position Birthday Salary 136 Sekou Doumbouya Detroit Pistons SF 2000-12-23 3285120 432 Talen Horton-Tucker Los Angeles Lakers GF 2000-11-25 898310 137 Zion Williamson New Orleans Pelicans F 2000-07-06 9757440 313 RJ Barrett New York Knicks SG 2000-06-14 7839960 392 Jalen Lecque Phoenix Suns G 2000-06-13 8983103.2 按多列排序 sort_values方法的by参数还支持按多个列排序,默认情况下,所有排序将按升序排列,也就是ascending参数默认值为True。下例按字母顺序对球队进行排序,然后再对每个球队中的球员进行排序: In [38]: nba.sort_values(by = ["Team", "Name"]) Out [38]: Name Team Position Birthday Salary 359 Alex Len Atlanta Hawks C 1993-06-16 4160000 167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000 276 Brandon Goodwin Atlanta Hawks PG 1995-10-02 79568 438 Bruno Fernando Atlanta Hawks C 1998-08-15 1400000 194 Cam Reddish Atlanta Hawks SF 1999-09-01 4245720 … … … … … … 418 Jordan McRae Washington Wizards PG 1991-03-28 1645357 273 Justin Robinson Washington Wizards PG 1997-10-12 898310 428 Moritz Wagner Washington Wizards C 1997-04-26 2063520 21 Rui Hachimura Washington Wizards PF 1998-02-08 4469160 36 Thomas Bryant Washington Wizards C 1997-07-31 800000 450 rows × 5 columns我们可以使用ascending参数对每个列按相同的顺序排序: In [39]: nba.sort_values(["Team", "Name"], ascending = False) Out [39]: Name Team Position Birthday Salary 36 Thomas Bryant Washington Wizards C 1997-07-31 8000000 21 Rui Hachimura Washington Wizards PF 1998-02-08 4469160 428 Moritz Wagner Washington Wizards C 1997-04-26 2063520 273 Justin Robinson Washington Wizards PG 1997-10-12 898310 418 Jordan McRae Washington Wizards PG 1991-03-28 1645357 … … … … … … 194 Cam Reddish Atlanta Hawks SF 1999-09-01 4245720 438 Bruno Fernando Atlanta Hawks C 1998-08-15 1400000 276 Brandon Goodwin Atlanta Hawks PG 1995-10-02 79568 167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000 359 Alex Len Atlanta Hawks C 1993-06-16 4160000 450 rows × 5 columns如果我们想对每个列按照不同的排序顺序,例如,对球队按升序进行排序,然后再对工资按降序进行排序。为此,ascending参数也支持列表值,每个布尔值会与by参数的每个值对应,也就是by和ascending参数的列表的长度必须相等。 In [40]: nba.sort_values(by = ["Team", "Salary"], ascending = [True, False]) Out [40]: Name Team Position Birthday Salary 111 Chandler Parsons Atlanta Hawks SF 1988-10-25 25102512 28 Evan Turner Atlanta Hawks PG 1988-10-27 18606556 167 Allen Crabbe Atlanta Hawks SG 1992-04-09 18500000 213 De'Andre Hunter Atlanta Hawks SF 1997-12-02 7068360 339 Jabari Parker Atlanta Hawks PF 1995-03-15 6500000 … … … … … … 80 Isaac Bonga Washington Wizards PG 1999-11-08 1416852 399 Admiral Schofield Washington Wizards SF 1997-03-30 1000000 273 Justin Robinson Washington Wizards PG 1997-10-12 898310 283 Garrison Mathews Washington Wizards SG 1996-10-24 79568 353 Chris Chiozza Washington Wizards PG 1995-11-21 79568 450 rows × 5 columns与Series一样,inplace参数会修改原始DataFrame而不是返回一个新的DataFrame。Jupyter Notebook中将不会产生任何输出: In [41]: nba.sort_values(by = ["Team", "Salary"], ascending = [True, False], inplace = True)4. 按DataFrame索引排序 使用inplace参数更改了原始的DataFrame,但我们也有方法将其恢复为原始形式。 4.1 按行索引排序 sort_index方法按索引值对DataFrame进行排序: In [42]: nba.sort_index().head() # 与下行代码是一样的 nba.sort_index(ascending = True).head() Out [42]: Name Team Position Birthday Salary 0 Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 1 Christian Wood Detroit Pistons PF 1995-09-27 1645357 2 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 3 Derrick Rose Detroit Pistons PG 1988-10-04 7317074 4 Marial Shayok Philadelphia 76ers G 1995-07-26 79568使用inplace参数使更改永久生效: In [43]: nba.sort_index(inplace = True)4.2 按列索引排序 按列进行排序可以使用axis参数,只需把值设为1或columns: In [44]: nba.sort_index(axis = 1).head() # 这三行代码是一样的 nba.sort_index(axis = "columns").head() nba.sort_index(axis = "columns", ascending = True).head() Out [44]: Birthday Name Position Salary Team 0 1996-09-26 Shake Milton SG 1445697 Philadelphia 76ers 1 1995-09-27 Christian Wood PF 1645357 Detroit Pistons 2 1998-08-23 PJ Washington PF 3831840 Charlotte Hornets 3 1988-10-04 Derrick Rose PG 7317074 Detroit Pistons 4 1995-07-26 Marial Shayok G 79568 Philadelphia 76ers5. 设置新索引 设置新索引可以使用set_index方法,它返回一个以给定列作为索引的新DataFrame: In [45]: nba.set_index(keys = "Name") # is the same as nba.set_index("Name") Out [45]: Team Position Birthday Salary Name Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 Christian Wood Detroit Pistons PF 1995-09-27 1645357 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 Derrick Rose Detroit Pistons PG 1988-10-04 7317074 Marial Shayok Philadelphia 76ers G 1995-07-26 79568 … … … … … Austin Rivers Houston Rockets PG 1992-08-01 2174310 Harry Giles Sacramento Kings PF 1998-04-22 2578800 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000 450 rows × 4 columns使用inplace参数使更改永久生效: In [46]: nba.set_index(keys = "Name", inplace = True)如果我们知道要在导入数据集时用作索引的列,我们还可以使用read_csv方法的index_col参数: In [47]: nba = pd.read_csv("nba.csv", parse_dates = ["Birthday"], index_col = "Name")6. 从DataFrame读取列 DataFrame是共用相同索引的Series对象的集合,我们可以轻松地从DataFrame中读取一个或多个这些列。 6.1 从DataFrame读取单列 每个Series的列都可以使用DataFrame的属性读取。例如,我们可以使用nba.Salary读取Salary列: In [48]: nba.Salary Out [48]: Name Shake Milton 1445697 Christian Wood 1645357 PJ Washington 3831840 Derrick Rose 7317074 Marial Shayo 79568 ... Austin Rivers 2174310 Harry Giles 2578800 Robin Lopez 4767000 Collin Sexton 4764960 Ricky Rubio 16200000 Name: Salary, Length: 450, dtype: int64如果您希望始终使用二维数据结构,可以使用to_frame方法将Series转换为DataFrame: In [49]: nba.Salary.to_frame() Out [49]: Salary Name Shake Milton 1445697 Christian Wood 1645357 PJ Washington 3831840 Derrick Rose 7317074 Marial Shayok 79568 … … Austin Rivers 2174310 Harry Giles 2578800 Robin Lopez 4767000 Collin Sexton 4764960 Ricky Rubio 16200000 450 rows × 1 columns也可以通过名称来读取列,这种方法的优点是它支持名称中带有空格的列。 In [50]: nba["Position"] Out [50]: Name Shake Milton SG Christian Wood PF PJ Washington PF Derrick Rose PG Marial Shayok G .. Austin Rivers PG Harry Giles PF Robin Lopez C Collin Sexton PG Ricky Rubio PG Name: Position, Length: 450, dtype: object6.2 从DataFrame读取多列 要读取多个列,只需要在列表中指定多个列名,返回的是一个新的DataFrame。它的列的排列顺序和列表中的一样,这是重新排列DataFrame列的有效方式: In [51]: nba[["Salary", "Birthday"]] Out [51]: Salary Birthday Name Shake Milton 1445697 1996-09-26 Christian Wood 1645357 1995-09-27 PJ Washington 3831840 1998-08-23 Derrick Rose 7317074 1988-10-04 Marial Shayok 79568 1995-07-26 … … … Austin Rivers 2174310 1992-08-01 Harry Giles 2578800 1998-04-22 Robin Lopez 4767000 1988-04-01 Collin Sexton 4764960 1999-01-04 Ricky Rubio 16200000 1990-10-21 450 rows × 2 columns如果我们想根据列的数据类型来选择列,可以使用select_dtypes方法,其include和exclude这两个参数可以指定单个数据类型或多个数据类型的列表。提醒一下,您可以使用dtypes属性查看数据集中的数据类型。 In [52]: # 仅选择字符串类型的列 ` nba.select_dtypes(include = "object") Out [52]: Team Position Name Shake Milton Philadelphia 76ers SG Christian Wood Detroit Pistons PF PJ Washington Charlotte Hornets PF Derrick Rose Detroit Pistons PG Marial Shayok Philadelphia 76ers G … … … Austin Rivers Houston Rockets PG Harry Giles Sacramento Kings PF Robin Lopez Milwaukee Bucks C Collin Sexton Cleveland Cavaliers PG Ricky Rubio Phoenix Suns PG 450 rows × 2 columns In [53]: # 排除字符串和整数类型的列 nba.select_dtypes(exclude = ["object", "int"]) Out [53]: Birthday Name Shake Milton 1996-09-26 Christian Wood 1995-09-27 PJ Washington 1998-08-23 Derrick Rose 1988-10-04 Marial Shayok 1995-07-26 … … Austin Rivers 1992-08-01 Harry Giles 1998-04-22 Robin Lopez 1988-04-01 Collin Sexton 1999-01-04 Ricky Rubio 1990-10-21 450 rows × 1 columns7. 从DataFrame读取行 DataFrame中的行可以通过索引标签或索引位置读取。 7.1 通过索引标签读取行 loc属性返回具有给定索引标签行的Series,注意是区分大小写。下例是返回索引标签是"LeBron James"的行: In [54]: nba.loc["LeBron James"] Out [54]: Team Los Angeles Lakers Position PF Birthday 1984-12-30 00:00:00 Salary 37436858 Name: LeBron James, dtype: object还可以给定一个列表以读取多行,返回结果是一个DataFrame,顺序和给定的列表一样: In [55]: nba.loc[["Kawhi Leonard", "Paul George"]] Out [55]: Team Position Birthday Salary Name Kawhi Leonard Los Angeles Clippers SF 1991-06-29 32742000 Paul George Los Angeles Clippers SF 1990-05-02 33005556Pandas还支持Python的列表切片语法。例如,我们可以对索引标签进行排序以按字母顺序获得球员的姓名,然后选择Otto Porter和Patrick Beverley之间的所有球员。注意,两个端点的球员也会被包括在内: In [56]: nba.sort_index().loc["Otto Porter":"Patrick Beverley"] Out [56]: Team Position Birthday Salary Name Otto Porter Chicago Bulls SF 1993-06-03 27250576 PJ Dozier Denver Nuggets PG 1996-10-25 79568 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 Pascal Siakam Toronto Raptors PF 1994-04-02 2351838 Pat Connaughton Milwaukee Bucks SG 1993-01-06 1723050 Patrick Beverley Los Angeles Clippers PG 1988-07-12 12345680我们还可以读取DataFrame从某行开始到最后一行的数据,它与从Python列表中读取分片的语法相同,也就是在初始索引标签后加一个冒号: In [57]: nba.sort_index().loc["Zach Collins":] Out [57]: Team Position Birthday Salary Name Zach Collins Portland Trail Blazers C 1997-11-19 4240200 Zach LaVine Chicago Bulls PG 1995-03-10 19500000 Zach Norvell Los Angeles Lakers SG 1997-12-09 79568 Zhaire Smith Philadelphia 76ers SG 1999-06-04 3058800 Zion Williamson New Orleans Pelicans F 2000-07-06 9757440 Zylan Cheatham New Orleans Pelicans SF 1995-11-17 79568同理可以读取DataFrame从开头到某行的数据,下例返回所从开头到"Al Horford"的行: In [58]: nba.sort_index().loc[:"Al Horford"] Out [58]: Team Position Birthday Salary Name Aaron Gordon Orlando Magic PF 1995-09-16 19863636 Aaron Holiday Indiana Pacers PG 1996-09-30 2239200 Abdel Nader Oklahoma City Thunder SF 1993-09-25 1618520 Adam Mokoka Chicago Bulls G 1998-07-1 79568 Admiral Schofield Washington Wizards SF 1997-03-30 1000000 Al Horford Philadelphia 76ers C 1986-06-03 28000000如果DataFrame中不存在指定的索引标签,则会抛出KeyError异常: In [59]: nba.loc["Bugs Bunny"] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) KeyError: 'Bugs Bunny'7.2 通过索引位置读取行 iloc(索引位置index location)属性返回具有给定索引位置的一行或多行,参数可以是单个整数或整数的列表: In [60]: nba.iloc[300] Out [60]: Team Denver Nuggets Position PF Birthday 1999-04-03 00:00:00 Salary 1416852 Name: Jarred Vanderbilt, dtype: object In [61]: nba.iloc[[100, 200, 300, 400]] Out [61]: Team Position Birthday Salary Name Brian Bowen Indiana Pacers SG 1998-10-02 79568 Marco Belinelli San Antonio Spurs SF 1986-03-25 5846154 Jarred Vanderbilt Denver Nuggets PF 1999-04-03 1416852 Louis King Detroit Pistons F 1999-04-06 79568列表切片的语法在这里也是使用的,需要注意冒号后面指定端点的行是不包括的。下例返回索引位置400、401、402和403的行: In [62]: nba.iloc[400:404] Out [62]: Team Position Birthday Salary Name Louis King Detroit Pistons F 1999-04-06 79568 Kostas Antetokounmpo Los Angeles Lakers PF 1997-11-20 79568 Rodions Kurucs Brooklyn Nets PF 1998-02-05 1699236 Spencer Dinwiddie Brooklyn Nets PG 1993-04-06 10605600 In [63]: nba.iloc[:2] # 读取头两行 Out [63]: Team Position Birthday Salary Name Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 Christian Wood Detroit Pistons PF 1995-09-27 1645357 In [64]: nba.iloc[447:] # 读取从索引位置447到最后 Out [64]: Team Position Birthday Salary Name Robin Lopez Milwaukee Bucks C 1988-04-01 4767000 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000索引位置也可以使用负数,也就是从倒数开始数。下例是从倒数第10行直到倒数第6行,但不包括倒数第6行: In [65]: nba.iloc[-10:-6] Out [65]: Team Position Birthday Salary Name Jared Dudley Los Angeles Lakers PF 1985-07-10 2564753 Max Strus ChicagoBulls SG 1996-03-28 79568 Kevon Looney Golden State Warriors C 1996-02-06 4464286 Willy Hernangomez Charlotte Hornets C 1994-05-27 1557250除此以外还可以指定索引位置的步长序列。在下例中,我们从前十行中选择间隔为2的行。因此,返回结果的索引位置为0、2、4、6和8: In [66]: nba.iloc[0:10:2] Out [66]: Team Position Birthday Salary Name Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 Marial Shayok Philadelphia 76ers G 1995-07-26 79568 Kendrick Nunn Miami Heat SG 1995-08-03 1416852 Brook Lopez Milwaukee Bucks C 1988-04-01 120930247.3 从行的指定列中读取值 loc和iloc属性都支持第二个参数指定要读取的列。在下例中,我们读取索引标签为"Giannis Antetokounmpo" 所在行的Team列的值: In [67]: nba.loc["Giannis Antetokounmpo", "Team"] Out [67]: 'Milwaukee Bucks'两个参数都支持传递列表,下例第二个参数使用列表指定要读取Position和Birthday列的值: In [68]: nba.loc["James Harden", ["Position", "Birthday"]] Out [68]: Position PG Birthday 1989-08-26 00:00:00 Name: James Harden, dtype: object下例第一、二个参数都使用了列表: In [69]: nba.loc[["Russell Westbrook", "Anthony Davis"], ["Team", "Salary"]] Out [69]: Team Salary Name Russell Westbrook Houston Rockets 38506482 Anthony Davis Los Angeles Lakers 27093019列表切片语法也可以用于读取多个列,注意,这里两个端点都将包括在内: In [70]: nba.loc["Joel Embiid", "Position":"Salary"] Out [70]: Position C Birthday 1994-03-16 00:00:00 Salary 27504630 Name: Joel Embiid, dtype: object参数指定的列名必须和它们在DataFrame中出现的顺序一样。下例会返回空列表,因为Salary列位于Position列之后: In [71]: nba.loc["Joel Embiid", "Salary":"Position"] Out [71]: Series([], Name: Joel Embiid, dtype: object)每个DataFrame列都分配有一个索引位置,在我们当前的DataFrame中,Team的索引为0,Position的索引为1,依此类推。 In [72]: nba.columns Out [72]: Index(['Team', 'Position', 'Birthday', 'Salary'], dtype='object')列的索引位置也可以作为第二个参数传给iloc: In [73]: nba.iloc[57, 3] Out [73]: 796806列表切片语法也可以在此处使用。下例返回索引位置100到104(不包括)所在行的从开始到索引位置3(不包括)的列: In [74]: nba.iloc[100:104, :3] Out [74]: Team Position Birthday Name Brian Bowen Indiana Pacers SG 1998-10-02 Aaron Holiday Indiana Pacers PG 1996-09-30 Troy Daniels Los Angeles Lakers SG 1991-07-15 Buddy Hield Sacramento Kings SG 1992-12-17iloc和loc属性非常通用,参数可以是单个值、列表、列表切片等。这种灵活性的缺点是需要额外的开销,pandas必须检查iloc或loc的输入类型。 当我们要从DataFrame中读取单个值时,可以使用at和iat这两个替代属性: at属性的参数是行和列标签,而iat属性的参数是行和列索引位置: In [75]: nba.at["Austin Rivers", "Birthday"] Out [75]: Timestamp('1992-08-01 00:00:00') In [76]: nba.iat[263, 1] Out [76]: 'PF'8. 重命名列或行 我们可以通过使用新名称列表覆盖columns属性来重命名DataFrame中的某些或所有列: In [77]: nba.columns Out [77]: Index(['Team', 'Position', 'Birthday', 'Salary'], dtype='object') In [78]: nba.columns = ["Team", "Position", "Date of Birth", "Pay"] nba.head(1) Out [78]: Team Position Date of Birth Pay Name Shake Milton Philadelphia 76ers SG 1996-09-26 1445697我们也可以使用rename方法,其参数columns的值类型是一个字典,键是需要修改的原列名,值是新的列名。下例是把原列名"Date of Birth"重命名为"Birthday": In [79]: nba.rename(columns = { "Date of Birth": "Birthday" }) Out [79]: Team Position Birthday Pay Name Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 Christian Woo Detroit Pistons PF 1995-09-27 1645357 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 Derrick Rose Detroit Pistons PG 1988-10-04 7317074 Marial Shayok Philadelphia 76ers G 1995-07-26 79568 … … … … … Austin Rivers Houston Rockets PG 1992-08-01 2174310 Harry Giles Sacramento Kings PF 1998-04-22 2578800 Robin Lopez Milwaukee Bucks C 1988-04-01 4767000 Collin Sexton Cleveland Cavaliers PG 1999-01-04 4764960 Ricky Rubio Phoenix Suns PG 1990-10-21 16200000 450 rows × 4 columns一如既往地,使用 inplace 参数使修改永久生效: In [80]: nba.rename( columns = { "Date of Birth": "Birthday" }, inplace = True )rename方法也可以重命名索引标签。下例将 "Giannis Antetokounmpo" 重命名为他的昵称 "Greek Freak": In [81]: nba.loc["Giannis Antetokounmpo"] Out [81]: Team Milwaukee Bucks Position PF Birthday 1994-12-06 00:00:00 Pay 25842697 Name: Giannis Antetokounmpo, dtype: object In [82]: nba.rename( index = { "Giannis Antetokounmpo": "Greek Freak" }, inplace = True ) In [83]: nba.loc["Greek Freak"] Out [83]: Team Milwaukee Bucks Position PF Birthday 1994-12-06 00:00:00 Pay 25842697 Name: Greek Freak, dtype: object9. 重置索引 如果我们想把另一列用作DataFrame的索引,可以使用set_index方法,但会造成当前索引Name的丢失: In [84]: nba.set_index("Team").head() Out [84]: Position Birthday Pay Team Philadelphia 76ers SG 1996-09-26 1445697 Detroit Pistons PF 1995-09-27 1645357 Charlotte Hornets PF 1998-08-23 3831840 Detroit Pistons PG 1988-10-04 7317074 Philadelphia 76ers G 1995-07-26 79568为了保留原来的索引列Name,我们首先要使用reset_index方法把现有索引重新整合为DataFrame中的常规列,并生成新的顺序索引: In [85]: nba.reset_index().head() Out [85]: Name Team Position Birthday Pay 0 Shake Milton Philadelphia 76ers SG 1996-09-26 1445697 1 Christian Wood Detroit Pistons PF 1995-09-27 1645357 2 PJ Washington Charlotte Hornets PF 1998-08-23 3831840 3 Derrick Rose Detroit Pistons PG 1988-10-04 7317074 4 Marial Shayok Philadelphia 76ers G 1995-07-26 79568现在我们可以放心使用set_index方法了: In [86]: nba.reset_index().set_index("Team").head() Out [86]: Name Position Birthday Pay Team Philadelphia 76ers Shake Milton SG 1996-09-26 1445697 Detroit Pistons Christian Wood PF 1995-09-27 1645357 Charlotte Hornets PJ Washington PF 1998-08-23 3831840 Detroit Pistons Derrick Rose PG 1988-10-04 7317074 Philadelphia 76ers Marial Shayok G 1995-07-26 79568reset_index方法也支持inplace参数,但是要注意:如果参数设置为True,则该方法将不会返回新的DataFrame,因此不能直接链接调用set_index方法,必须依次分开单独调用: In [87]: nba.reset_index(inplace = True) nba.set_index("Name", inplace = True)
END O(∩_∩)O |
CopyRight 2018-2019 办公设备维修网 版权所有 豫ICP备15022753号-3 |